diff --git a/pkg/sessions/persistence/manager.go b/pkg/sessions/persistence/manager.go
index 3215b25..a8491cf 100644
--- a/pkg/sessions/persistence/manager.go
+++ b/pkg/sessions/persistence/manager.go
@@ -3,6 +3,7 @@ package persistence
 import (
 	"fmt"
 	"net/http"
+	"strings"
 	"time"

 	"github.com/oauth2-proxy/oauth2-proxy/v7/pkg/apis/options"
@@ -33,7 +34,7 @@ func (m *Manager) Save(rw http.ResponseWriter, req *http.Request, s *sessions.Se
 		s.CreatedAtNow()
 	}

-	tckt, err := decodeTicketFromRequest(req, m.Options)
+	tckt, _, err := decodeTicketFromRequest(req, m.Options)
 	if err != nil {
 		tckt, err = newTicket(m.Options)
 		if err != nil {
@@ -54,23 +55,36 @@ func (m *Manager) Save(rw http.ResponseWriter, req *http.Request, s *sessions.Se
 // Load reads sessions.SessionState information from a session store. It will
 // use the session ticket from the http.Request's cookie.
 func (m *Manager) Load(req *http.Request) (*sessions.SessionState, error) {
-	tckt, err := decodeTicketFromRequest(req, m.Options)
+	tckt, refreshToken, err := decodeTicketFromRequest(req, m.Options)
 	if err != nil {
 		return nil, err
 	}

-	return tckt.loadSession(
+	state, err := tckt.loadSession(
 		func(key string) ([]byte, error) {
 			return m.Store.Load(req.Context(), key)
 		},
 		m.Store.Lock,
 	)
+
+	if err != nil && strings.HasPrefix(err.Error(), "failed to load the session state with the ticket") {
+		// Suppress redis loadig errors, because in this case we have a refresh token in cookie
+		err = nil
+	}
+
+	if state == nil {
+		createdAt, _ := time.Parse(time.RFC3339, "1992-09-30T00:00:00Z")
+		state = &sessions.SessionState{CreatedAt: &createdAt, User: "Does not found in Redis"}
+	}
+
+	state.RefreshToken = refreshToken
+	return state, err
 }

 // Clear clears any saved session information for a given ticket cookie.
 // Then it clears all session data for that ticket in the Store.
 func (m *Manager) Clear(rw http.ResponseWriter, req *http.Request) error {
-	tckt, err := decodeTicketFromRequest(req, m.Options)
+	tckt, _, err := decodeTicketFromRequest(req, m.Options)
 	if err != nil {
 		// Always clear the cookie, even when we can't load a cookie from
 		// the request
diff --git a/pkg/sessions/persistence/ticket.go b/pkg/sessions/persistence/ticket.go
index 70bb58a..9ccd847 100644
--- a/pkg/sessions/persistence/ticket.go
+++ b/pkg/sessions/persistence/ticket.go
@@ -5,6 +5,7 @@ import (
 	"crypto/rand"
 	"encoding/base64"
 	"encoding/hex"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
@@ -43,6 +44,11 @@ type ticket struct {
 	options *options.Cookie
 }

+type cookieRefreshToken struct {
+	Ticket       string `json:"Ticket"`
+	RefreshToken string `json:"RefreshToken"`
+}
+
 // newTicket creates a new ticket. The ID & secret will be randomly created
 // with 16 byte sizes. The ID will be prefixed & hex encoded.
 func newTicket(cookieOpts *options.Cookie) (*ticket, error) {
@@ -71,38 +77,45 @@ func (t *ticket) encodeTicket() string {
 }

 // decodeTicket decodes an encoded ticket string
-func decodeTicket(encTicket string, cookieOpts *options.Cookie) (*ticket, error) {
-	ticketParts := strings.Split(encTicket, ".")
+func decodeTicket(encTicket string, cookieOpts *options.Cookie) (*ticket, string, error) {
+	var value cookieRefreshToken
+
+	if err := json.Unmarshal([]byte(encTicket), &value); err != nil {
+		return nil, "", fmt.Errorf("failed to unmarshal cookie: %w", err)
+	}
+
+	ticketParts := strings.Split(value.Ticket, ".")
 	if len(ticketParts) != 2 {
-		return nil, errors.New("failed to decode ticket")
+		return nil, "", errors.New("failed to decode ticket")
 	}
+
 	ticketID, secretBase64 := ticketParts[0], ticketParts[1]

 	secret, err := base64.RawURLEncoding.DecodeString(secretBase64)
 	if err != nil {
-		return nil, fmt.Errorf("failed to decode encryption secret: %v", err)
+		return nil, "", fmt.Errorf("failed to decode encryption secret: %v", err)
 	}

 	return &ticket{
 		id:      ticketID,
 		secret:  secret,
 		options: cookieOpts,
-	}, nil
+	}, value.RefreshToken, nil
 }

 // decodeTicketFromRequest retrieves a potential ticket cookie from a request
 // and decodes it to a ticket.
-func decodeTicketFromRequest(req *http.Request, cookieOpts *options.Cookie) (*ticket, error) {
+func decodeTicketFromRequest(req *http.Request, cookieOpts *options.Cookie) (*ticket, string, error) {
 	requestCookie, err := req.Cookie(cookieOpts.Name)
 	if err != nil {
 		// Don't wrap this error to allow `err == http.ErrNoCookie` checks
-		return nil, err
+		return nil, "", err
 	}

 	// An existing cookie exists, try to retrieve the ticket
 	val, _, ok := encryption.Validate(requestCookie, cookieOpts.Secret, cookieOpts.Expire)
 	if !ok {
-		return nil, fmt.Errorf("session ticket cookie failed validation: %v", err)
+		return nil, "", fmt.Errorf("session ticket cookie failed validation: %v", err)
 	}

 	// Valid cookie, decode the ticket
@@ -130,7 +143,7 @@ func (t *ticket) saveSession(s *sessions.SessionState, saver saveFunc) error {
 func (t *ticket) loadSession(loader loadFunc, initLock initLockFunc) (*sessions.SessionState, error) {
 	ciphertext, err := loader(t.id)
 	if err != nil {
-		return nil, fmt.Errorf("failed to load the session state with the ticket: %v", err)
+		return nil, fmt.Errorf("failed to load the session state with the ticket: %w", err)
 	}
 	c, err := t.makeCipher()
 	if err != nil {
@@ -154,9 +167,19 @@ func (t *ticket) clearSession(clearer clearFunc) error {

 // setCookie sets the encoded ticket as a cookie
 func (t *ticket) setCookie(rw http.ResponseWriter, req *http.Request, s *sessions.SessionState) error {
+	value := cookieRefreshToken{
+		Ticket:       t.encodeTicket(),
+		RefreshToken: s.RefreshToken,
+	}
+
+	data, err := json.Marshal(value)
+	if err != nil {
+		return fmt.Errorf("failed to marshal cookie: %w", err)
+	}
+
 	ticketCookie, err := t.makeCookie(
 		req,
-		t.encodeTicket(),
+		string(data),
 		t.options.Expire,
 		*s.CreatedAt,
 	)
